home *** CD-ROM | disk | FTP | other *** search
/ C/C++ Interactive Reference Guide / C-C++ Interactive Reference Guide.iso / c_ref / csource4 / 219_01 / a65.c < prev    next >
Text File  |  1989-01-13  |  13KB  |  472 lines
  1. /*
  2.     HEADER:        CUG219;
  3.     TITLE:        6502 Cross-Assembler (Portable);
  4.     FILENAME:    A65.C;
  5.     VERSION:    0.1;
  6.     DATE:        08/27/1988;
  7.  
  8.     DESCRIPTION:    "This program lets you use your computer to assemble
  9.             code for the MOS Technology 6502 microprocessors.  The
  10.             program is written in portable C rather than BDS C.
  11.             All assembler features are supported except relocation
  12.             linkage, and macros.";
  13.  
  14.     KEYWORDS:    Software Development, Assemblers, Cross-Assemblers,
  15.             MOS Technology, 6502;
  16.  
  17.     SYSTEM:        CP/M-80, CP/M-86, HP-UX, MSDOS, PCDOS, QNIX;
  18.     COMPILERS:    Aztec C86, Aztec CII, CI-C86, Eco-C, Eco-C88, HP-UX,
  19.             Lattice C, Microsoft C,    QNIX C;
  20.  
  21.     WARNINGS:    "This program is written in as portable C as possible.
  22.             A port to BDS C would be extremely difficult, but see
  23.             volume CUG113.  A port to Toolworks C is untried."
  24.  
  25.     AUTHORS:    William C. Colley III;
  26. */
  27.  
  28. /*
  29.               6502 Cross-Assembler in Portable C
  30.  
  31.            Copyright (c) 1986 William C. Colley, III
  32.  
  33. Revision History:
  34.  
  35. Ver    Date        Description
  36.  
  37. 0.0    NOV 1986    Derived from my 6800/6801 cross-assembler.  WCC3.
  38.  
  39. 0.1    AUG 1988    Fixed a bug in the command line parser that puts it
  40.             into a VERY long loop if the user types a command line
  41.             like "A65 FILE.ASM -L".  WCC3 per Alex Cameron.
  42.  
  43. This file contains the main program and line assembly routines for the
  44. assembler.  The main program parses the command line, feeds the source lines to
  45. the line assembly routine, and sends the results to the listing and object file
  46. output routines.  It also coordinates the activities of everything.  The line
  47. assembly routines uses the expression analyzer and the lexical analyzer to
  48. parse the source line and convert it into the object bytes that it represents.
  49. */
  50.  
  51. /*  Get global goodies:  */
  52.  
  53. #include "a65.h"
  54.  
  55. /*  Define global mailboxes for all modules:                */
  56.  
  57. char errcode, line[MAXLINE + 1], title[MAXLINE];
  58. int pass = 0;
  59. int eject, filesp, forwd, listhex;
  60. unsigned address, argattr, bytes, errors, listleft, obj[MAXLINE], pagelen, pc;
  61. FILE *filestk[FILES], *source;
  62. TOKEN token;
  63.  
  64. /*  Mainline routine.  This routine parses the command line, sets up    */
  65. /*  the assembler at the beginning of each pass, feeds the source text    */
  66. /*  to the line assembler, feeds the result to the listing and hex file    */
  67. /*  drivers, and cleans everything up at the end of the run.        */
  68.  
  69. static int done, ifsp, off;
  70.  
  71. void main(argc,argv)
  72. int argc;
  73. char **argv;
  74. {
  75.     SCRATCH unsigned *o;
  76.     int newline();
  77.     void asm_line();
  78.     void lclose(), lopen(), lputs();
  79.     void hclose(), hopen(), hputc();
  80.     void error(), fatal_error(), warning();
  81.  
  82.     printf("6502 Cross-Assembler (Portable) Ver 0.1\n");
  83.     printf("Copyright (c) 1986 William C. Colley, III\n\n");
  84.  
  85.     while (--argc > 0) {
  86.     if (**++argv == '-') {
  87.         switch (toupper(*++*argv)) {
  88.         case 'L':   if (!*++*argv) {
  89.                 if (!--argc) { warning(NOLST);  break; }
  90.                 else ++argv;
  91.                 }
  92.                 lopen(*argv);
  93.                 break;
  94.  
  95.         case 'O':   if (!*++*argv) {
  96.                 if (!--argc) { warning(NOHEX);  break; }
  97.                 else ++argv;
  98.                 }
  99.                 hopen(*argv);
  100.                 break;
  101.  
  102.         default:    warning(BADOPT);
  103.         }
  104.     }
  105.     else if (filestk[0]) warning(TWOASM);
  106.     else if (!(filestk[0] = fopen(*argv,"r"))) fatal_error(ASMOPEN);
  107.     }
  108.     if (!filestk[0]) fatal_error(NOASM);
  109.  
  110.     while (++pass < 3) {
  111.     fseek(source = filestk[0],0L,0);  done = off = FALSE;
  112.     errors = filesp = ifsp = pagelen = pc = 0;  title[0] = '\0';
  113.     while (!done) {
  114.         errcode = ' ';
  115.         if (newline()) {
  116.         error('*');
  117.         strcpy(line,"\tEND\n");
  118.         done = eject = TRUE;  listhex = FALSE;
  119.         bytes = 0;
  120.         }
  121.         else asm_line();
  122.         pc = word(pc + bytes);
  123.         if (pass == 2) {
  124.         lputs();
  125.         for (o = obj; bytes--; hputc(*o++));
  126.         }
  127.     }
  128.     }
  129.  
  130.     fclose(filestk[0]);  lclose();  hclose();
  131.  
  132.     if (errors) printf("%d Error(s)\n",errors);
  133.     else printf("No Errors\n");
  134.  
  135.     exit(errors);
  136. }
  137.  
  138. /*  Line assembly routine.  This routine gets the contents of the    */
  139. /*  argument field from the source file using the expression evaluator    */
  140. /*  and lexical analyzer.  It makes all validity checks on the        */
  141. /*  arguments validity, fills a buffer with the machine code bytes and    */
  142. /*  returns nothing.                            */
  143.  
  144. static char label[MAXLINE];
  145. static int ifstack[IFDEPTH] = { ON };
  146.  
  147. static OPCODE *opcod;
  148.  
  149. void asm_line()
  150. {
  151.     SCRATCH int i;
  152.     int isalph(), popc();
  153.     OPCODE *find_code(), *find_operator();
  154.     void do_label(), flush(), normal_op(), pseudo_op();
  155.     void error(), pops(), pushc(), trash();
  156.  
  157.     address = pc;  bytes = 0;  eject = forwd = listhex = FALSE;
  158.     for (i = 0; i < BIGINST; obj[i++] = NOP);
  159.  
  160.     label[0] = '\0';
  161.     if ((i = popc()) != ' ' && i != '\n') {
  162.     if (isalph(i)) {
  163.         pushc(i);  pops(label);
  164.         if (find_operator(label)) { label[0] = '\0';  error('L'); }
  165.     }
  166.     else {
  167.         error('L');
  168.         while ((i = popc()) != ' ' && i != '\n');
  169.     }
  170.     }
  171.  
  172.     trash();  opcod = NULL;
  173.     if ((i = popc()) != '\n') {
  174.     if (!isalph(i)) error('S');
  175.     else {
  176.         pushc(i);  pops(token.sval);
  177.         if (!(opcod = find_code(token.sval))) error('O');
  178.     }
  179.     if (!opcod) { listhex = TRUE;  bytes = BIGINST; }
  180.     }
  181.  
  182.     if (opcod && opcod -> attr & ISIF) { if (label[0]) error('L'); }
  183.     else if (off) { listhex = FALSE;  flush();  return; }
  184.  
  185.     if (!opcod) { do_label();  flush(); }
  186.     else {
  187.     listhex = TRUE;
  188.     if (opcod -> attr & PSEUDO) pseudo_op();
  189.     else normal_op();
  190.     while ((i = popc()) != '\n') if (i != ' ') error('T');
  191.     }
  192.     source = filestk[filesp];
  193.     return;
  194. }
  195.  
  196. static void flush()
  197. {
  198.     while (popc() != '\n');
  199. }
  200.  
  201. static void do_label()
  202. {
  203.     SCRATCH SYMBOL *l;
  204.     SYMBOL *find_symbol(), *new_symbol();
  205.     void error();
  206.  
  207.     if (label[0]) {
  208.     listhex = TRUE;
  209.     if (pass == 1) {
  210.         if (!((l = new_symbol(label)) -> attr)) {
  211.         l -> attr = FORWD + VAL;
  212.         l -> valu = pc;
  213.         }
  214.     }
  215.     else {
  216.         if (l = find_symbol(label)) {
  217.         l -> attr = VAL;
  218.         if (l -> valu != pc) error('M');
  219.         }
  220.         else error('P');
  221.     }
  222.     }
  223. }
  224.  
  225. static void normal_op()
  226. {
  227.     SCRATCH unsigned opcode, operand;
  228.     unsigned do_args();
  229.     void do_label(), error();
  230.  
  231.     opcode = opcod -> valu;  bytes = BIGINST;
  232.     do_label();  operand = do_args();
  233.     switch (opcod -> attr) {
  234.     case CPXY:  if (argattr & ARGIMM) goto do_immediate;
  235.             opcode += 0x04;
  236.  
  237.     case BITOP: if (argattr != ARGNUM) { error('A');  return; }
  238.             goto do_zero_page;
  239.  
  240.     case INHOP: if (argattr) error('T');
  241.                 bytes = 1;  break;
  242.  
  243.     case JUMP:  if (argattr == (ARGIND + ARGNUM)) {
  244.             opcode += 0x20;  break;
  245.             }
  246.  
  247.     case CALL:  if (argattr != ARGNUM) { error('A');  return; }
  248.             break;
  249.  
  250.     case LOGOP: if (!(argattr & ARGA)) goto do_inc_op;
  251.             opcode += 0x04;  bytes = 1;  break;
  252.  
  253.     case RELBR: if (argattr != ARGNUM) { error('A');  return; }
  254.                 bytes = 2;  operand -= pc + 2;
  255.             if (clamp(operand) > 0x007f && operand < 0xff80) {
  256.             error('B');  operand = 0xfffe;
  257.             }
  258.             break;
  259.  
  260.     case STXY:  if ((argattr & (opcode == 0x86 ? ~ARGY : ~ARGX)) !=
  261.             ARGNUM) { error ('A');  return; }
  262.             if (argattr & (ARGX + ARGY)) {
  263.             if (operand > 0x00ff) {    error('V');  operand = 0; }
  264.             opcode += 0x10;  bytes = 2;  break;
  265.             }
  266.             goto do_zero_page;
  267.  
  268.     case TWOOP: if (!(argattr & ARGNUM)) { error('A');  return; }
  269.             if (argattr & ARGIMM) {
  270.             if (opcode == 0x81) { error('A');  return; }
  271.             opcode += 0x08;  goto do_immediate;
  272.             }
  273.             if (argattr & ARGIND) {
  274.             if (argattr & ARGY) opcode += 0x10;
  275.             else if (!(argattr & ARGX)) { error('A');  return; }
  276.             if (operand > 0x00ff) { error('V');  operand = 0; }
  277.             bytes = 2;
  278.             }
  279.             else if (argattr & ARGY) opcode += 0x18;
  280.             else { opcode += 0x04;  goto do_indexed_x; }
  281.             break;
  282.  
  283.     case LDXY:  if (!(argattr & ARGIMM)) {
  284.             if (opcode == 0xa2 && (argattr & ARGY))
  285.                 argattr ^= (ARGX + ARGY);
  286.             opcode += 0x04;  goto do_inc_op;
  287.             }
  288. do_immediate:        if (operand > 0x00ff && operand < 0xff80) {
  289.             error('V');  operand = 0;
  290.             }
  291.             bytes = 2;  break;
  292.  
  293. do_inc_op:
  294.     case INCOP: if ((argattr & ~ARGX) != ARGNUM) { error('A');  return; }
  295. do_indexed_x:        if (argattr & ARGX) opcode += 0x10;
  296. do_zero_page:        if (!forwd && operand <= 0x00ff) bytes = 2;
  297.             else opcode += 0x08;
  298.             break;
  299.     }
  300.     obj[2] = high(operand);  obj[1] = low(operand);  obj[0] = opcode;
  301.     return;
  302. }
  303.  
  304. static void pseudo_op()
  305. {
  306.     SCRATCH char *s;
  307.     SCRATCH unsigned *o, u;
  308.     SCRATCH SYMBOL *l;
  309.     unsigned expr();
  310.     SYMBOL *find_symbol(), *new_symbol();
  311.     TOKEN *lex();
  312.     void do_label(), error(), fatal_error(), hseek(), unlex();
  313.  
  314.     o = obj;
  315.     switch (opcod -> valu) {
  316.     case ELSE:  listhex = FALSE;
  317.             if (ifsp) off = (ifstack[ifsp] = -ifstack[ifsp]) != ON;
  318.             else error('I');
  319.             break;
  320.  
  321.     case END:   do_label();
  322.             if (filesp) { listhex = FALSE;  error('*'); }
  323.             else {
  324.             done = eject = TRUE;
  325.             if (pass == 2 && (lex() -> attr & TYPE) != EOL) {
  326.                 unlex();  hseek(address = expr());
  327.             }
  328.             if (ifsp) error('I');
  329.             }
  330.             break;
  331.  
  332.     case ENDI:  listhex = FALSE;
  333.             if (ifsp) off = ifstack[--ifsp] != ON;
  334.             else error('I');
  335.             break;
  336.  
  337.     case EQU:   if (label[0]) {
  338.             if (pass == 1) {
  339.                 if (!((l = new_symbol(label)) -> attr)) {
  340.                 l -> attr = FORWD + VAL;
  341.                 address = expr();
  342.                 if (!forwd) l -> valu = address;
  343.                 }
  344.             }
  345.             else {
  346.                 if (l = find_symbol(label)) {
  347.                 l -> attr = VAL;
  348.                 address = expr();
  349.                 if (forwd) error('P');
  350.                 if (l -> valu != address) error('M');
  351.                 }
  352.                 else error('P');
  353.             }
  354.             }
  355.             else error('L');
  356.             break;
  357.  
  358.     case FCB:   do_label();
  359.             do {
  360.             if ((lex() -> attr & TYPE) == SEP) u = 0;
  361.             else {
  362.                 unlex();
  363.                 if ((u = expr()) > 0xff && u < 0xff80) {
  364.                 u = 0;  error('V');
  365.                 }
  366.             }
  367.             *o++ = low(u);  ++bytes;
  368.             } while ((token.attr & TYPE) == SEP);
  369.             break;
  370.  
  371.     case FCC:   do_label();
  372.             while ((lex() -> attr & TYPE) != EOL) {
  373.             if ((token.attr & TYPE) == STR) {
  374.                 for (s = token.sval; *s; *o++ = *s++)
  375.                 ++bytes;
  376.                 if ((lex() -> attr & TYPE) != SEP) unlex();
  377.             }
  378.             else error('S');
  379.             }
  380.             break;
  381.  
  382.     case FDB:   do_label();
  383.             do {
  384.             if ((lex() -> attr & TYPE) == SEP) u = 0;
  385.             else { unlex();  u = expr(); }
  386.             *o++ = low(u);  *o++ = high(u);
  387.             bytes += 2;
  388.             } while ((token.attr & TYPE) == SEP);
  389.             break;
  390.  
  391.     case IF:    if (++ifsp == IFDEPTH) fatal_error(IFOFLOW);
  392.             address = expr();
  393.             if (forwd) { error('P');  address = TRUE; }
  394.             if (off) { listhex = FALSE;  ifstack[ifsp] = NULL; }
  395.             else {
  396.             ifstack[ifsp] = address ? ON : OFF;
  397.             if (!address) off = TRUE;
  398.             }
  399.             break;
  400.  
  401.     case INCL:  listhex = FALSE;  do_label();
  402.             if ((lex() -> attr & TYPE) == STR) {
  403.             if (++filesp == FILES) fatal_error(FLOFLOW);
  404.             if (!(filestk[filesp] = fopen(token.sval,"r"))) {
  405.                 --filesp;  error('V');
  406.             }
  407.             }
  408.             else error('S');
  409.             break;
  410.  
  411.     case ORG:   u = expr();
  412.             if (forwd) error('P');
  413.             else {
  414.             pc = address = u;
  415.             if (pass == 2) hseek(pc);
  416.             }
  417.             do_label();
  418.             break;
  419.  
  420.     case PAGE:  listhex = FALSE;  do_label();
  421.             if ((lex() -> attr & TYPE) != EOL) {
  422.             unlex();  pagelen = expr();
  423.             if (pagelen > 0 && pagelen < 3) {
  424.                 pagelen = 0;  error('V');
  425.             }
  426.             }
  427.             eject = TRUE;
  428.             break;
  429.  
  430.     case RMB:   do_label();
  431.             u = word(pc + expr());
  432.             if (forwd) error('P');
  433.             else {
  434.             pc = u;
  435.             if (pass == 2) hseek(pc);
  436.             }
  437.             break;
  438.  
  439.     case SET:   if (label[0]) {
  440.             if (pass == 1) {
  441.                 if (!((l = new_symbol(label)) -> attr)
  442.                 || (l -> attr & SOFT)) {
  443.                 l -> attr = FORWD + SOFT + VAL;
  444.                 address = expr();
  445.                 if (!forwd) l -> valu = address;
  446.                 }
  447.             }
  448.             else {
  449.                 if (l = find_symbol(label)) {
  450.                 address = expr();
  451.                 if (forwd) error('P');
  452.                 else if (l -> attr & SOFT) {
  453.                     l -> attr = SOFT + VAL;
  454.                     l -> valu = address;
  455.                 }
  456.                 else error('M');
  457.                 }
  458.                 else error('P');
  459.             }
  460.             }
  461.             else error('L');
  462.             break;
  463.  
  464.     case TITL:  listhex = FALSE;  do_label();
  465.             if ((lex() -> attr & TYPE) == EOL) title[0] = '\0';
  466.             else if ((token.attr & TYPE) != STR) error('S');
  467.             else strcpy(title,token.sval);
  468.             break;
  469.     }
  470.     return;
  471. }
  472.